Infrastruktuur koodina: Terraformi Pythoni pakkujate valdamine globaalseks automatiseerimiseks

Pilvandmetöötluse ja IT-operatsioonide kiiresti arenevas maastikus on Infrastruktuur koodina (IaC) muutunud asendamatuks praktikaks. See võimaldab organisatsioonidel hallata oma infrastruktuuri masinloetavate definitsioonifailide kaudu, mitte füüsilise riistvara konfiguratsiooni või interaktiivsete konfiguratsioonitööriistade abil. Juhtivate IaC tööriistade seas paistab HashiCorp Terraform silma oma võimega hallata infrastruktuuri erinevates pilvepakkujates ja kohapealsetes keskkondades deklaratiivse konfiguratsioonikeelega.

Kuigi Terraformi omapärased pakkujad hõlmavad laias valikus teenuseid suurtelt pilvemüüjatelt nagu AWS, Azure ja Google Cloud, samuti arvukaid SaaS-i platvorme, on juhtumeid, kus on vaja kohandatud integratsiooni. Siin tuleb mängu Terraformi Pythoni pakkujate jõud. Arendades oma pakkujad Pythoni abil, saate laiendada Terraformi võimalusi, et hallata praktiliselt kõiki API-põhiseid teenuseid, võimaldades oma globaalseteks operatsioonideks keerukaid ja kohandatud automatiseerimisstrateegiaid.

Infrastruktuur koodina (IaC) olemus

Enne Pythoni pakkujatesse sukeldumist on ülioluline mõista IaC põhiprintsiipe. Põhiidee on käsitleda oma infrastruktuuri – servereid, võrke, andmebaase, koormusjaotureid ja muud – nagu see oleks tarkvara. See tähendab tarkvaraarenduse parimate praktikate, nagu versioonikontroll, testimine ja pidev integreerimine/pidev tarnimine (CI/CD), rakendamist oma infrastruktuuri haldamisele.

IaC peamised eelised:

• Järjepidevus ja reprodutseeritavus: IaC tagab, et teie infrastruktuur juurutatakse iga kord järjepidevalt, vähendades konfiguratsioonihälbe ja inimlike vigade riski. See on ülimalt oluline globaalsetele organisatsioonidele, mis tegutsevad erinevates regulatiivsetes ja operatsioonilistes keskkondades.
• Kiirus ja tõhusus: Infrastruktuuri ettevalmistamise ja haldamise automatiseerimine kiirendab oluliselt juurutustsüklit, võimaldades meeskondadel kiiremini reageerida ärilistele nõudmistele.
• Kulude kokkuhoid: Kaotades käsitsi tehtava töö ja vähendades vigu, aitab IaC kaasa madalamatele tegevuskuludele. Tõhus ressursside haldamine aitab ka pilve kulutusi optimeerida.
• Riskide vähendamine: Versioonikontrollitud konfiguratsioonid võimaldavad hõlpsalt tagasi pöörduda eelmiste stabiilsete olekute juurde, minimeerides seisakuid ja maandades muudatustega seotud riske.
• Skaleeritavus: IaC muudab infrastruktuuri üles- või allapoole skaleerimise lihtsamaks vastuseks muutuvatele nõudmistele, mis on kriitiline võimalus ettevõtetele, kellel on kõikuvad globaalsed kasutajabaasid.

HashiCorp Terraform: Deklaratiivne lähenemine infrastruktuurile

Terraform kasutab deklaratiivset keelt nimega HashiCorp Configuration Language (HCL), et määratleda oma infrastruktuuri soovitud olek. Sa määrad, milline sa tahad, et su infrastruktuur välja näeks, ja Terraform mõtleb välja, kuidas seda olekut saavutada, suheldes oma pilvepakkujate või teenuste vastavate API-dega.

Terraformi arhitektuur on üles ehitatud pakkujate ümber. Pakkuja on abstraktsioon, mis võimaldab Terraformil suhelda konkreetse API-ga. Näiteks AWS-i pakkuja võimaldab Terraformil hallata AWS-i ressursse, Azure'i pakkuja aga Azure'i ressursse.

Kuidas Terraform töötab:

1. Kirjuta konfiguratsioon: Sa määrad oma infrastruktuuri `.tf` failides, kasutades HCL-i.
2. Initsialiseeri: `terraform init` käsk laadib alla vajalikud pakkujad.
3. Plaan: `terraform plan` näitab sulle, milliseid muudatusi Terraform teeb, et saavutada soovitud olek.
4. Rakenda: `terraform apply` täidab plaani ja valmistab ette või muudab su infrastruktuuri.

Kui omapärastest pakkujatest ei piisa

Kuigi Terraformi ökosüsteemil on sadu ametlikke ja kogukonna poolt hallatavaid pakkujaid, on mitmeid stsenaariume, kus kohandatud pakkuja arendamine muutub vajalikuks:

• Varalised süsteemid: Sise tööriistade, kohandatud ehitatud platvormide või pärandsüsteemide haldamine, millel pole kergesti kättesaadavaid Terraformi pakkujaid.
• Spetsialiseeritud SaaS-i platvormid: Integreerimine niši Tarkvara-kui-Teenus rakendustega või sisemiste mikroteenustega, mis paljastavad API-sid, kuid puudub ametlik Terraformi tugi.
• Keerukad töövoogud: Toimingute orkestreerimine mitmes teenuses, mis nõuavad keerukat loogikat või kohandatud andmete teisendusi, mida olemasolevad pakkujad ei toeta omapäraselt.
• Varased kasutajad: Ressursside haldamine uute pilveteenuste või API-de jaoks enne ametlike pakkujate arendamist.
• Täiustatud turvalisus ja valitsemine: Konkreetsete turvapoliitikate või vastavuskontrollide rakendamine, mis nõuavad kohandatud ressursside haldamise loogikat.

Globaalsete ettevõtete jaoks on oluline eelis võime standardiseerida erinevate sise- ja välisteenuste haldamist erinevates geograafilistes piirkondades. Kohandatud pakkujad tagavad, et isegi kõige unikaalsemaid või varalisemaid süsteeme saab tuua IaC katuse alla, edendades ühtsust ja kontrolli.

Tutvustame Terraformi Pythoni pakkujaid

Terraformi pakkujad on tavaliselt kirjutatud Go-s. Kuid HashiCorp pakub ka Terraform Plugin SDK-d, mis võimaldab arendajatel ehitada pakkujaid teistes keeltes. Kuigi see pole nii tavaline kui Go, on Python populaarne valik Terraformi pakkujate arendamiseks tänu oma ulatuslikele teekidele, kasutusmugavusele ja suurele arendajate kogukonnale.

Terraformi pakkuja arendamine Pythonis hõlmab pistikprogrammi loomist, mida Terraform saab laadida ja millega suhelda. See pistikprogramm toimib vahendajana, tõlkides Terraformi taotlused (ressursside loomiseks, lugemiseks, värskendamiseks või kustutamiseks) API-kõnedeks sihtteenusele ja seejärel tõlkides teenuse vastused tagasi Terraformile.

Terraformi pistikprogrammi arhitektuur

Terraform suhtleb pakkujatega gRPC (Google Remote Procedure Call) protokolli kaudu. Kui ehitate pakkuja muus keeles kui Go, ehitate sisuliselt eraldiseisva käivitatava faili, mis vastab sellele protokollile. Terraform käivitab selle käivitatava faili pistikprogrammina ja suhtleb sellega.

Pythoni jaoks tähendab see, et teie pakkuja on Pythoni skript, mis rakendab vajalikud liidesed, et suhelda Terraformi põhioperatsioonidega iga ressursitüübi ja andmeallika jaoks, mida soovite hallata.

Oma esimese Terraformi Pythoni pakkuja ehitamine

Terraformi Pythoni pakkuja ehitamise protsessi saab jagada mitmeks peamiseks etapiks. Kasutame kontseptuaalset näidet illustreerimiseks:

Kontseptuaalne näide: Kohandatud "Vidin" teenuse haldamine

Kujutage ette, et teil on sisemine API-teenus, mis haldab "vidinaid". See teenus võimaldab teil luua, lugeda, värskendada ja kustutada vidinaid, millest igal ühel on nimi ja kirjeldus. Meie eesmärk on ehitada Terraformi pakkuja nende vidinate haldamiseks.

Eeltingimused:

• Python 3.6+ installitud
• `pip` pakettide haldamiseks
• HTTP API-de ja JSON-i põhiline mõistmine
• Terraform installitud

1. samm: Arenduskeskkonna seadistamine

Teil on vaja installida Pythoni teek, mis aitab ületada lõhet Terraformi gRPC protokolli ja teie Pythoni koodi vahel. Kõige silmapaistvam teek selleks on terraform-provider-sdk. Kuigi ametlik Terraform Plugin SDK on peamiselt Go-põhine, kasutavad kogukonna jõupingutused ja tööriistad sageli olemasolevaid RPC raamistikke.

Tavaline lähenemisviis on kasutada teeki, mis ümbritseb gRPC kõnesid. Kuid lihtsuse ja illustreerimise huvides visandame kontseptuaalse struktuuri. Reaalses stsenaariumis kasutaksite tõenäoliselt raamistikku, mis tegeleb teie eest gRPC torutöödega.

2. samm: Ressursside ja andmeallikate määratlemine

Terraformis on infrastruktuurikomponendid esindatud ressurssidena (nt virtuaalmasin, andmebaas) või andmeallikatena (nt olemasolevate ressursside päringud). Teie pakkuja peab määratlema, kuidas Terraform saab suhelda teie "vidina" ressursiga.

Pythoni pakkuja määratleb tavaliselt funktsioone või meetodeid, mis vastavad Terraformi CRUD (Loo, Loe, Värskenda, Kustuta) toimingutele iga ressursitüübi jaoks.

3. samm: Ressursiloogika rakendamine

Visandame hüpoteetilise `vidina` ressursi struktuuri:

Skeemi definitsioon:

Peate määratlema oma ressursi atribuudid. See ütleb Terraformile, milliseid andmeid oodata ja kuidas neid käsitleda.

            {
  "block": {
    "attributes": {
      "id": {
        "Type": "String",
        "Description": "Vidina unikaalne identifikaator.",
        "Computed": true
      },
      "name": {
        "Type": "String",
        "Description": "Vidina nimi.",
        "Required": true
      },
      "description": {
        "Type": "String",
        "Description": "Vidina lühikirjeldus.",
        "Optional": true
      }
    }
  }
}

            

              
                Copy
              
            
          

CRUD toimingud (kontseptuaalne Python):

Sa määratleksid funktsioonid, mis suhtlevad teie "vidina" API-ga:

            # See on lihtsustatud, kontseptuaalne esitus

class WidgetResource:
    def __init__(self, api_client):
        self.api_client = api_client

    def Create(self, data):
        # Helistage oma vidina API-le, et vidin luua
        widget_data = {
            "name": data.get("name"),
            "description": data.get("description")
        }
        response = self.api_client.post("/widgets", json=widget_data)
        return {
            "id": response.json()["id"],
            "name": response.json()["name"],
            "description": response.json()["description"]
        }

    def Read(self, id):
        # Helistage oma vidina API-le, et vidin ID järgi hankida
        response = self.api_client.get(f"/widgets/{id}")
        if response.status_code == 404:
            return None # Ressurssi ei leitud
        return {
            "id": response.json()["id"],
            "name": response.json()["name"],
            "description": response.json()["description"]
        }

    def Update(self, id, data):
        # Helistage oma vidina API-le, et vidinat värskendada
        widget_data = {
            "name": data.get("name"),
            "description": data.get("description")
        }
        response = self.api_client.put(f"/widgets/{id}", json=widget_data)
        return {
            "id": response.json()["id"],
            "name": response.json()["name"],
            "description": response.json()["description"]
        }

    def Delete(self, id):
        # Helistage oma vidina API-le, et vidin kustutada
        self.api_client.delete(f"/widgets/{id}")

            

              
                Copy
              
            
          

4. samm: Pakkuja pakendamine

Terraformi pakkujad kompileeritakse eraldiseisvateks käivitatavateks failideks. Kui ehitate Pythoni pakkuja, kompileerite tavaliselt oma Pythoni koodi käivitatavaks failiks, mida Terraform saab käitada. Tööriistad nagu pyinstaller või spetsiifilised raamistiku tööriistad võivad selles aidata.

Käivitatav fail tuleb paigutada konkreetsesse kataloogistruktuuri, mille Terraform leiab. Tavaliselt hõlmab see kataloogi nagu ~/.terraform.d/plugins/registry.terraform.io////_/.

Näide Terraformi konfiguratsioonist:

Oma Terraformi konfiguratsioonis (`.tf` failid) viitaksite oma kohandatud pakkujale:

            terraform {
  required_providers {
    customwidget = {
      source = "registry.terraform.io//customwidget"
      version = "1.0.0"
    }
  }
}

provider "customwidget" {
  # Pakkuja konfiguratsiooniargumendid nagu API lõpp-punkt, mandaadid jne.
  api_endpoint = "http://your-widget-api.internal:8080"
}

resource "customwidget_widget" "example" {
  name        = "my-cool-widget"
  description = "See on vidin, mida haldab kohandatud Terraformi pakkuja."
}

            

              
                Copy
              
            
          

Kui käivitate `terraform init`, otsib Terraform `customwidget` pakkuja määratud asukohast. Kui seda ei leita avalikust registrist, otsib see kohalikest pistikprogrammide kataloogidest.

Pythoni teekide kasutamine täiustatud funktsioonide jaoks

Pythoni kasutamise tõeline jõud Terraformi pakkujate jaoks seisneb Pythoni teekide laias ökosüsteemis. See võimaldab:

• Keerukad API interaktsioonid: Teegid nagu `requests` muudavad HTTP taotlused lihtsaks ja vastupidavaks.
• Andmete manipuleerimine: Teeke nagu `pandas` või `numpy` saab kasutada täiustatud andmetöötluseks, kui teie API interaktsioonid on keerukad.
• Autentimine: Pythonil on suurepärased teegid erinevate autentimismehhanismide (OAuth, JWT, API võtmed) käsitlemiseks.
• Logimine ja veakäsitlus: Pythoni standardne logimismoodul ja tugev erandite käsitlemine tagavad usaldusväärsemad pakkujad.
• Integreerimine olemasoleva Pythoni koodiga: Kui teil on olemasolevaid Pythoni skripte või teeke, mis haldavad teie kohandatud teenuseid, saate need sageli otse oma pakkujasse integreerida, vähendades koodi dubleerimist.

Näide: `requests` kasutamine API kõnede jaoks

`requests` teek on de facto standard HTTP taotluste tegemiseks Pythonis. See lihtsustab GET, POST, PUT, DELETE taotluste saatmist ja vastuste käsitlemist.

            import requests

def get_widget_by_id(api_url, widget_id):
    try:
        response = requests.get(f"{api_url}/widgets/{widget_id}")
        response.raise_for_status() # Tõsta erand halva olekukoodi (4xx või 5xx) korral
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Viga vidina {widget_id} toomisel: {e}")
        return None

            

              
                Copy
              
            
          

Globaalsed kaalutlused Terraformi Pythoni pakkujate jaoks

Terraformi Pythoni pakkujate kavandamisel ja juurutamisel globaalsele publikule tulevad mängu mitmed tegurid:

1. Piirkondlikud API lõpp-punktid ja mandaadid

Pilvepakkujatel ja SaaS-i platvormidel on sageli erinevad API lõpp-punktid ja autentimismehhanismid erinevate geograafiliste piirkondade jaoks. Teie pakkuja peaks olema kujundatud nii, et:

• Aktsepteeri piirkonnaspetsiifilist konfiguratsiooni: Laske kasutajatel määrata hallatava teenuse piirkond või lõpp-punkt.
• Hallake piirkondlikke mandaate: Tagage iga piirkonna mandaatide turvaline haldamine ja kasutamine. See võib hõlmata piirkonnaspetsiifiliste API võtmete edastamist või mandaatide haldussüsteemi kasutamist.

Näide pakkuja konfiguratsioonist piirkondlike lõpp-punktide jaoks:

            provider "customwidget" {
  api_endpoint = "https://widget-api.us-east-1.example.com"
  api_key      = var.aws_api_key # Eeldades Terraformi muutujat mandaatide jaoks
}

            

              
                Copy
              
            
          

2. Rahvusvahelistamine ja lokaliseerimine (I18n/L10n)

Kuigi Terraform ise ja selle konfiguratsioonikeel (HCL) on tavaliselt inglise keeles, võivad teie kohandatud pakkuja hallatavad andmed sisaldada stringe, mida on vaja lokaliseerida. Kui teie "vidina" teenus salvestab kasutajale suunatud kirjeldusi või silte, kaaluge, kuidas teie pakkuja neid käsitleda saab:

• Lokaliseeritud atribuutide lubamine: Teie pakkuja skeem võib sisaldada erinevate keelte atribuute (nt `description_en`, `description_fr`).
• Viitamine lokaliseerimisteenustele: Kui teil on spetsiaalne lokaliseerimisteenus, võib teie pakkuja sellega suhelda.

3. Ajavööndid ja andmevormingud

API-dega suhtlemisel, mis tegelevad ajatemplite või kuupäevadega, olge teadlik ajavöönditest ja erinevatest kuupäevavormingutest. Veenduge, et teie pakkuja parsib ja vormindab neid väärtusi korrektselt vastavalt API nõuetele ja kasutajate oodatavale käitumisele erinevates ajavööndites.

4. Vastavus ja andmete asukoht

Globaalses kontekstis on vastavus sellistele määrustele nagu GDPR, CCPA ja teised kriitilise tähtsusega. Kui teie kohandatud pakkuja haldab ressursse, mis sisaldavad tundlikke andmeid, veenduge, et teie pakkuja loogika austab andmete asukohanõudeid. See võib hõlmata:

• Ressursside loomise suunamine konkreetsetesse geograafilistesse asukohtadesse.
• Vajadusel andmete anonümiseerimise või pseudonümiseerimise rakendamine.
• Tagamine, et aluseks olevad API kõned järgivad vastavusstandardeid.

5. Jõudlus ja latentsus

Erinevates geograafilistes asukohtades olevate kasutajate jaoks võib API kõnede latentsus olla oluline tegur. Kui teie pakkuja teeb palju järjestikuseid API kõnesid või kui aluseks oleval teenusel on kõrge latentsus:

• Optimeeri API kõnesid: Partiitoimingud, kui võimalik.
• Asünkroonsed toimingud: Kui aluseks olev API toetab asünkroonseid toiminguid, kasutage neid, et vältida Terraformi blokeerimist pikemaks ajaks.
• Pakkuja vahemälu: Rakenda vahemälu mehhanisme oma pakkujas sageli juurdepääsetavate, mitte-lenduvate andmete jaoks.

Oma Pythoni pakkuja testimine

Põhjalik testimine on ülioluline mis tahes infrastruktuurikoodi puhul ja kohandatud pakkujad pole erand. Hästi testitud pakkuja suurendab usaldust ja vähendab operatsioonilist riski teie kasutajatele kogu maailmas.

Testimise tüübid:

• Ühiku testid: Testige üksikuid funktsioone ja meetodeid oma pakkuja koodis isoleeritult. Siin saate API vastuseid jäljendada, et loogikat kontrollida.
• Integratsiooni testid: Testige interaktsiooni oma pakkuja koodi ja tegeliku siht API vahel. See hõlmab sageli teenuse testeksemplari juurutamist või liivakasti keskkonna kasutamist.
• Nõustumistestid: Need on terviklikud testid, mis simuleerivad kasutaja juurutus infrastruktuuri, kasutades teie pakkuja. Siin saate käivitada Terraformi käske (`init`, `plan`, `apply`, `destroy`) oma pakkuja vastu.

Terraformil on sisseehitatud testimisraamistikud, mida saab kasutada. Pythoni pakkujate puhul integreerite oma Pythoni testimiskomplekti (nt `pytest`) Terraformi testimisvõimalustega.

Oma Pythoni pakkuja avaldamine ja levitamine

Kui teie pakkuja on välja töötatud ja testitud, soovite selle teha kättesaadavaks oma meeskondadele või laiemale publikule.

Levitamise võimalused:

• Sisemine pistikprogrammide kataloog: Ettevõtte kasutamiseks võite juhendada kasutajaid paigutama kompileeritud pakkuja käivitatava faili oma kohalikku Terraformi pistikprogrammide kataloogi.
• Privaatne Terraformi register: HashiCorp pakub Terraform Cloudi ja Enterprise'i, mis sisaldavad privaatse registri võimalusi, võimaldades teil oma pakkujaid turvaliselt oma organisatsioonis majutada ja versioonida.
• Avalik Terraformi register: Kui teie pakkuja on avatud lähtekoodiga ja kogukonnale kasulik, saate selle avaldada avalikus Terraformi registris. See hõlmab teie pakkuja allkirjastamist ja konkreetsete pakendamisnõuete järgimist.

Alternatiivid ja täiustatud kontseptsioonid

Kuigi täieliku pakkuja ehitamine Pythonis on võimas, on lihtsamate integratsioonide jaoks alternatiivseid lähenemisviise:

• Terraform `local-exec` ja `remote-exec`: Väga lihtsate ülesannete jaoks saate käivitada kohalikke skripte (võimalik, et Pythoni skripte) otse oma Terraformi konfiguratsioonis. Üldiselt ei soovitata seda infrastruktuuri oleku haldamiseks, kuid see võib olla kasulik ühekordsete toimingute või seadistusülesannete jaoks.
• Terraform `null_resource` koos `provisioner` plokkidega: Sarnaselt `local-exec` võib see käivitada väliseid skripte.
• Terraform väline andmeallikas: See võimaldab Terraformil käivitada välist käivitatavat faili (nagu Pythoni skript) ja kasutada selle JSON väljundit andmetena. See sobib suurepäraselt dünaamiliste andmete hankimiseks, mis ei vaja Terraformi oleku haldamist.

Pakkuja ehitamine Go-s vs. Pythonis

Go:

• Plussid: Ametlik SDK on Go-põhine, mis viib tihedama integratsioonini ja potentsiaalselt parema jõudluseni. Kohalik kompileerimine.
• Miinused: Järsem õppimiskõver arendajatele, kes pole Go-ga tuttavad.

• Plussid: Kättesaadav laiemale arendajabaasile. Rikkalik teekide ökosüsteem. Kiire prototüüpimine.
• Miinused: Nõuab levitamiseks hoolikat pakendamist. Potentsiaal Go pakkujatega võrreldes veidi suuremateks üldkuludeks.

Parimad praktikad Terraformi Pythoni pakkujate arendamiseks

Tagamaks, et teie kohandatud pakkujad on tugevad, hooldatavad ja kasutajasõbralikud kogu maailmas:

• Järgige Terraformi pakkuja arendusjuhiseid: Isegi kui kasutate Pythonit, järgige Terraformi konventsioone ressursiskeemi, olekuhalduse ja API interaktsioonide jaoks.
• Seadke esikohale idempotentsus: Veenduge, et sama konfiguratsiooni mitmekordne rakendamine tooks kaasa sama oleku ilma soovimatute kõrvalmõjudeta.
• Käsitle vigu graatsiliselt: Esitage selged ja rakendatavad veateated. Globaalsete kasutajate jaoks peaksid need teated olema arusaadavad, ilma et oleks vaja sügavaid teadmisi oma sisemiste süsteemide kohta.
• Hallake olekut tõhusalt: Terraform tugineb olekule hallatavate ressursside jälgimiseks. Teie pakkuja peab Terraformile täpselt teatama ressursside praeguse oleku.
• Dokumenteerige põhjalikult: Esitage põhjalik dokumentatsioon, sealhulgas installijuhised, konfiguratsioonivalikud, näited ja veaotsingu näpunäited. Globaalse publiku jaoks veenduge, et dokumentatsioon on selge, lühike ja väldib võimaluse korral žargooni.
• Versioonige oma pakkujat: Kasutage semantilist versioonimist, et hallata muudatusi ja tagada tagasiühilduvus.
• Turvalised mandaadid: Ärge kunagi kodeerige tundlikku teavet. Kasutage keskkonnamuutujaid, Terraformi sisendmuutujaid ja turvalisi mandaatide haldussüsteeme.

Järeldus

Infrastruktuur koodina pole enam niši praktika, vaid kaasaegsete IT-operatsioonide nurgakivi, mis võimaldab paindlikkust, järjepidevust ja tõhusust. Kuigi Terraformi ulatuslik ametlike pakkujate kataloog hõlmab valdav enamus kasutusjuhtumeid, avab kohandatud pakkujate, eriti Pythoni abil arendamise võimalus piiramatud automatiseerimise võimalused.

Terraformi Pythoni pakkujate valdamisega saavad organisatsioonid laiendada IaC-d varaliste süsteemide haldamiseks, integreerida spetsialiseeritud API-dega ja orkestreerida keerukaid töövoogusid. See annab globaalsetele meeskondadele võimaluse säilitada ühtne, deklaratiivne lähenemisviis infrastruktuuri haldamisele erinevates pilvekeskkondades ja sisemistes teenustes, edendades uuendusi ja operatsioonilist tipptaset ülemaailmses mastaabis. Kuna teie organisatsiooni infrastruktuurivajadused muutuvad keerukamaks ja spetsialiseeritumaks, on investeerimine kohandatud pakkuja arendusse strateegiline eelis, tagades, et teie automatiseerimisstrateegia on sama ainulaadne ja võimas kui teie ettevõte.